#include "vgmainwindow.h"
#include "ui_vgmainwindow.h"
#include "TabManager.h"
#include "DockingArea.h"
#include "DockTab.h"
#include "DockingTabWell.h"
#include "QOverlay.h"
#include <QApplication>
#include <QCloseEvent>
#include <QShowEvent>
#include <QSettings>
#include <QTextEdit>
#include <QTreeView>
#include <QListWidget>
#include <QLabel>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QTimer>
#include <QFile>
#include <QTextStream>
#include <QDebug>
#include <cassert>

VGMainWindow::VGMainWindow(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::VGMainWindow)
    , TabManagerInstance(nullptr)
    , DockingAreaInstance(nullptr)
    , DynamicMainTabWell(nullptr)
{
    ui->setupUi(this);      // Qt Designer自动生成的方法
    
    initializeMainWindow(); // 我们的自定义初始化
    setupDockingSystem();
    setupConnections();
    registerDefaultTabTypes();
    
    // 默认布局现在在initializeMainWindow()中直接调用
}

VGMainWindow::~VGMainWindow()
{
    saveSettings();
    delete ui;
}

// === 初始化 ===

void VGMainWindow::initializeMainWindow()
{
    qDebug() << "=== VGMainWindow::initializeMainWindow() 开始 ===";
    
    // 设置应用图标
    setupApplicationIcon();
    
    // 加载QSS样式文件
    loadStyleSheet();
    
    // 设置窗口属性
    setWindowTitle("VGameEngine Editor");
    setMinimumSize(1024, 768);
    resize(1280, 720);
    
    // 设置无边框窗口（模拟UE5的自定义标题栏）
    // 暂时注释掉无边框设置，先确保窗口能正常显示
    // setWindowFlags(Qt::FramelessWindowHint);
    // setAttribute(Qt::WA_TranslucentBackground, false);
    
    // 获取UI组件引用
    DockingAreaInstance = ui->dockingArea;
    qDebug() << "DockingAreaInstance:" << DockingAreaInstance;
    
    // 先创建覆盖式标签页和菜单栏布局（包括动态创建mainTabWell）
    setupOverlayTabAndMenuBar();
    
    // 然后创建默认布局（添加标签到动态创建的mainTabWell）
    createDefaultLayout();

    // 连接主标签栏激活信号 -> 切换中央内容
    if (DynamicMainTabWell)
    {
        connect(DynamicMainTabWell, &DockingTabWell::tabActivated,
                this, &VGMainWindow::onMainWellTabActivated);
        // 确保初始显示为主编辑器内容
        updateCentralContentForTab(DynamicMainTabWell->foregroundTab());
    }
    
    loadSettings();
    
    qDebug() << "=== VGMainWindow::initializeMainWindow() 完成 ===";
}

void VGMainWindow::setupApplicationIcon()
{
    // 设置应用程序图标（使用Qt标准图标）
    QIcon appIcon = style()->standardIcon(QStyle::SP_ComputerIcon);
    setWindowIcon(appIcon);
    
    // 注意：应用角标和菜单按钮现在在setupOverlayTabAndMenuBar()中动态创建
}

void VGMainWindow::setupMenuButtonIcons()
{
    // 菜单按钮现在在setupOverlayTabAndMenuBar()中动态创建，不再需要这个函数
    // 保留函数定义以避免头文件引用错误
}

void VGMainWindow::setupDockingSystem()
{
    // 断言：TabManager不应该已经存在
    assert(TabManagerInstance == nullptr && "TabManager should not already exist");
    
    // 创建标签页管理器
    TabManagerInstance = new TabManager(this);
    
    // 设置主停靠区域
    if (DockingAreaInstance)
    {
        TabManagerInstance->setPrimaryArea(DockingAreaInstance);
        DockingAreaInstance->setTabManager(TabManagerInstance);
    }
    else
    {
        assert(false && "DockingArea should exist before setting up docking system");
    }
}

void VGMainWindow::setupConnections()
{
    // 连接标签页管理器信号
    if (TabManagerInstance)
    {
        connect(TabManagerInstance, &TabManager::tabSpawned, this, &VGMainWindow::onTabSpawned);
        connect(TabManagerInstance, &TabManager::tabClosed, this, &VGMainWindow::onTabClosed);
    }
}

// === 标签页注册 ===

void VGMainWindow::registerDefaultTabTypes()
{
    if (!TabManagerInstance) return;
    
    // 注册视口标签页
    TabSpawnInfo viewportInfo;
    viewportInfo.tabId = "Viewport";
    viewportInfo.displayName = "Viewport";
    viewportInfo.icon = style()->standardIcon(QStyle::SP_DesktopIcon); // 3D视口图标
    viewportInfo.isSingleton = true;
    viewportInfo.isClosable = false; // 视口不可关闭

    viewportInfo.contentFactory = []() -> QWidget*
    {
        QWidget* viewport = new QWidget();
        
        QVBoxLayout* layout = new QVBoxLayout(viewport);
        QLabel* label = new QLabel("3D Viewport\n(Render Area)");
        label->setAlignment(Qt::AlignCenter);
        layout->addWidget(label);
        
        return viewport;
    };

    TabManagerInstance->registerTabSpawner(viewportInfo);
    
    // 注册内容浏览器
    TabSpawnInfo contentBrowserInfo;
    contentBrowserInfo.tabId = "ContentBrowser";
    contentBrowserInfo.displayName = "Content Browser";
    contentBrowserInfo.icon = style()->standardIcon(QStyle::SP_DirIcon); // 文件夹图标
    contentBrowserInfo.isSingleton = true;
    contentBrowserInfo.canMoveToSidebar = true;

    contentBrowserInfo.contentFactory = []() -> QWidget*
    {
        QTreeView* tree = new QTreeView();
        return tree;
    };

    TabManagerInstance->registerTabSpawner(contentBrowserInfo);
    
    // 注册世界大纲
    TabSpawnInfo outlinerInfo;
    outlinerInfo.tabId = "WorldOutliner";
    outlinerInfo.displayName = "World Outliner";
    outlinerInfo.icon = style()->standardIcon(QStyle::SP_FileDialogListView); // 列表视图图标
    outlinerInfo.isSingleton = true;
    outlinerInfo.canMoveToSidebar = true;

    outlinerInfo.contentFactory = []() -> QWidget*
    {
        QTreeView* tree = new QTreeView();
        return tree;
    };

    TabManagerInstance->registerTabSpawner(outlinerInfo);
    
    // 注册详情面板
    TabSpawnInfo detailsInfo;
    detailsInfo.tabId = "DetailsPanel";
    detailsInfo.displayName = "Details";
    detailsInfo.icon = style()->standardIcon(QStyle::SP_FileDialogDetailedView); // 详细视图图标
    detailsInfo.isSingleton = true;
    detailsInfo.canMoveToSidebar = true;

    detailsInfo.contentFactory = []() -> QWidget*
    {
        QListWidget* list = new QListWidget();
        list->addItem("Property 1");
        list->addItem("Property 2");
        list->addItem("Property 3");
        return list;
    };

    TabManagerInstance->registerTabSpawner(detailsInfo);
    
    // 注册输出日志
    TabSpawnInfo outputInfo;
    outputInfo.tabId = "OutputLog";
    outputInfo.displayName = "Output Log";
    outputInfo.icon = style()->standardIcon(QStyle::SP_ComputerIcon); // 控制台图标
    outputInfo.isSingleton = true;

    outputInfo.contentFactory = []() -> QWidget*
    {
        QTextEdit* textEdit = new QTextEdit();
        textEdit->setPlainText("VGameEngine Editor Started\nReady for development...");
        textEdit->setReadOnly(true);
        return textEdit;
    };

    TabManagerInstance->registerTabSpawner(outputInfo);
}

// === 布局管理 ===

void VGMainWindow::createDefaultLayout()
{
    if (!DockingAreaInstance) return;
    
    // 创建UE5风格的默认布局
    DockingAreaInstance->createUE4LikeLayout();
    
    // 在动态创建的主标签栏添加一些标签页
    if (DynamicMainTabWell)
    {
        qDebug() << "动态mainTabWell 存在，开始添加标签页";
        
        // 添加默认的主标签页（模仿UE5的关卡标签）
        auto levelTab = new DockTab("VGameEngineMap", DynamicMainTabWell);
        levelTab->setTabType(DockTab::TabType::MainTab);
        levelTab->setTabIcon(style()->standardIcon(QStyle::SP_DirHomeIcon)); // 使用Qt标准图标
        
        // 由DockingTabWell自适应计算标签宽度，避免间隙
        levelTab->show();
        levelTab->setVisible(true);
        
        // 添加到主标签栏（主标签应该是激活的）
        DynamicMainTabWell->addTab(levelTab, -1, false);
        DynamicMainTabWell->bringTabToFront(0); // 使用正确的方法名：bringTabToFront
        qDebug() << "添加了关卡标签页: VGameEngineMap，索引:" << DynamicMainTabWell->getTabIndex(levelTab);
        
        // 可以添加更多标签页（类似UE5的蓝图编辑器）
        auto blueprintTab = new DockTab("MyBlueprint", DynamicMainTabWell);
        blueprintTab->setTabType(DockTab::TabType::DocumentTab);
        blueprintTab->setTabIcon(style()->standardIcon(QStyle::SP_FileDialogDetailedView)); // 蓝图图标
        
        // 由DockingTabWell自适应计算标签宽度，避免间隙
        blueprintTab->show();
        blueprintTab->setVisible(true);
        
        DynamicMainTabWell->addTab(blueprintTab, -1, true); // 保持非激活状态
        qDebug() << "添加了蓝图标签页: MyBlueprint，索引:" << DynamicMainTabWell->getTabIndex(blueprintTab);
        
        // 检查标签页数量
        qDebug() << "动态mainTabWell 当前标签页数量:" << DynamicMainTabWell->tabCount();
        qDebug() << "动态mainTabWell 可见性:" << DynamicMainTabWell->isVisible();
        qDebug() << "动态mainTabWell 大小:" << DynamicMainTabWell->size();
    }
    else
    {
        qDebug() << "错误: 动态mainTabWell 不存在!";
    }
    
    updateMenuStates();
}

void VGMainWindow::createUE4LikeLayout()
{
    if (DockingAreaInstance)
    {
        DockingAreaInstance->createUE4LikeLayout();
    }
}

// === Qt事件重写 ===

void VGMainWindow::closeEvent(QCloseEvent* event)
{
    saveSettings();
    event->accept();
}

void VGMainWindow::showEvent(QShowEvent* event)
{
    QWidget::showEvent(event);
    
    // 首次显示时的初始化
    static bool firstShow = true;

    if (firstShow)
    {
        firstShow = false;
        updateMenuStates();
        
    }
}

// === 菜单操作槽函数 ===

void VGMainWindow::onShowFileMenu()
{
    // 显示文件菜单
    // 这里可以创建QMenu并显示
}

void VGMainWindow::onShowEditMenu()
{
    // 显示编辑菜单
}

void VGMainWindow::onShowWindowMenu()
{
    // 显示窗口菜单
}

void VGMainWindow::onNewProject()
{
    // 新建项目
}

void VGMainWindow::onOpenProject()
{
    // 打开项目
}

void VGMainWindow::onSaveProject()
{
    // 保存项目
}

void VGMainWindow::onExit()
{
    close();
}

// === 视图菜单 ===

void VGMainWindow::onShowViewport()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->spawnTab("Viewport");
    }
}

void VGMainWindow::onShowContentBrowser()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->spawnTab("ContentBrowser");
    }
}

void VGMainWindow::onShowWorldOutliner()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->spawnTab("WorldOutliner");
    }
}

void VGMainWindow::onShowDetailsPanel()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->spawnTab("DetailsPanel");
    }
}

void VGMainWindow::onShowOutputLog()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->spawnTab("OutputLog");
    }
}

// === 窗口菜单 ===

void VGMainWindow::onResetLayout()
{
    if (DockingAreaInstance)
    {
        DockingAreaInstance->resetToDefaultLayout();
    }
}

void VGMainWindow::onSaveLayout()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->saveLayout("UserLayout");
    }
}

void VGMainWindow::onLoadLayout()
{
    if (TabManagerInstance)
    {
        TabManagerInstance->loadLayout("UserLayout");
    }
}

// === 标签页事件 ===

void VGMainWindow::onTabSpawned(DockTab* tab)
{
    if (ui->statusLabel)
    {
        ui->statusLabel->setText(QString("Opened: %1").arg(tab->tabTitle()));
    }
    updateMenuStates();
}

void VGMainWindow::onTabClosed(DockTab* tab)
{
    if (ui->statusLabel)
    {
        ui->statusLabel->setText(QString("Closed: %1").arg(tab->tabTitle()));
    }
    updateMenuStates();
}

// === 工具函数 ===

void VGMainWindow::updateMenuStates()
{
    // 更新菜单状态
    // 这里可以根据当前打开的标签页状态更新菜单项
}

void VGMainWindow::saveSettings()
{
    QSettings settings;
    settings.beginGroup("MainWindow");
    settings.setValue("geometry", saveGeometry());
    // QWidget没有saveState方法，移除这行
    settings.endGroup();
    
    // 保存布局
    if (TabManagerInstance)
    {
        TabManagerInstance->saveLayout("LastSession");
    }
}

void VGMainWindow::loadSettings()
{
    QSettings settings;
    settings.beginGroup("MainWindow");
    restoreGeometry(settings.value("geometry").toByteArray());
    // QWidget没有restoreState方法，移除这行
    settings.endGroup();
}

void VGMainWindow::loadStyleSheet()
{
    qDebug() << "=== 开始加载QSS样式 ===";
    
    // 从资源文件加载QSS样式
    QFile file(":/styles/dark_theme.qss");
    qDebug() << "尝试从资源文件加载:" << file.fileName();
    
    if (file.open(QFile::ReadOnly | QFile::Text))
    {
        QTextStream stream(&file);
        QString styleSheet = stream.readAll();
        qDebug() << "✅ 资源文件加载成功，样式长度:" << styleSheet.length();
        qDebug() << "样式内容预览:" << styleSheet.left(200) + "...";
        qApp->setStyleSheet(styleSheet);
        file.close();
        qDebug() << "✅ QSS样式已应用到应用程序";
    }
    else
    {
        qDebug() << "❌ 资源文件加载失败，尝试从文件系统加载";
        // 如果资源文件加载失败，尝试从文件系统加载
        QFile localFile("styles/dark_theme.qss");
        qDebug() << "尝试从本地文件加载:" << localFile.fileName();
        
        if (localFile.open(QFile::ReadOnly | QFile::Text))
        {
            QTextStream stream(&localFile);
            QString styleSheet = stream.readAll();
            qDebug() << "✅ 本地文件加载成功，样式长度:" << styleSheet.length();
            qApp->setStyleSheet(styleSheet);
            localFile.close();
            qDebug() << "✅ QSS样式已应用到应用程序";
        }
        else
        {
            qDebug() << "❌ 本地文件也加载失败！";
            qDebug() << "错误信息:" << localFile.errorString();
        }
    }
    
    qDebug() << "=== QSS样式加载完成 ===";
}

// === 主标签内容切换 ===
void VGMainWindow::onMainWellTabActivated(DockTab* tab, int index)
{
    Q_UNUSED(index);
    updateCentralContentForTab(tab);
}

void VGMainWindow::updateCentralContentForTab(DockTab* tab)
{
    // centralStack: page0=mainEditorPage(真正编辑器DockingArea), page1=emptyPlaceholderPage
    if (!ui->centralStack) return;

    // 规则：主标签显示真正编辑器；其他标签显示占位（后续可替换为具体编辑器/文档）
    if (tab && tab->tabType() == DockTab::TabType::MainTab)
    {
        ui->centralStack->setCurrentWidget(ui->mainEditorPage);
    }
    else
    {
        ui->centralStack->setCurrentWidget(ui->emptyPlaceholderPage);
    }
}


void VGMainWindow::setupOverlayTabAndMenuBar()
{
    qDebug() << "=== setupOverlayTabAndMenuBar() 开始 ===";
    
    // 获取原始的标签页和菜单栏区域
    QWidget* tabAndMenuBar = ui->tabAndMenuBar;
    if (!tabAndMenuBar)
    {
        qDebug() << "错误: tabAndMenuBar 为 null!";
        return;
    }
    
    qDebug() << "tabAndMenuBar 找到:" << tabAndMenuBar;
    
    // 先清除UI文件中的现有布局内容，但保留布局本身
    QLayout* existingLayout = tabAndMenuBar->layout();
    if (existingLayout)
    {
        // 清除布局中的所有项目，但不删除布局本身
        QLayoutItem* child;
        while ((child = existingLayout->takeAt(0)) != nullptr)
        {
            if (child->widget())
            {
                child->widget()->setParent(nullptr);
            }

            delete child;
        }
    }
    
    // 创建QOverlay来管理这个区域的覆盖布局
    auto overlay = new QOverlay(tabAndMenuBar);
    
    // 将overlay添加到现有的布局中
    if (existingLayout)
    {
        existingLayout->addWidget(overlay);
    }
    else
    {
        // 如果没有现有布局，创建一个新的
        auto layout = new QVBoxLayout(tabAndMenuBar);
        layout->setContentsMargins(0, 0, 0, 0);
        layout->addWidget(overlay);
    }
    
    // === 实现2x2角标 + 正确的重叠布局 ===
    
    // 1. 动态创建角标区域（占用左上角2x2网格，A1-B2，Z-Value: 1）
    auto appIconWidget = new QWidget();
    auto iconLayout = new QHBoxLayout(appIconWidget);
    iconLayout->setContentsMargins(8, 4, 8, 4);
    
    // 动态创建角标标签
    auto appIconLabel = new QLabel("🎮");
    appIconLabel->setAlignment(Qt::AlignCenter);
    appIconLabel->setObjectName("appIconLabel");
    iconLayout->addWidget(appIconLabel);
    
    appIconWidget->setFixedSize(64, 60); // 2x2网格：宽64px，高60px
    appIconWidget->setObjectName("appIconArea");
    overlay->addWidget(appIconWidget, 1, OverlayAlignment::TopLeft, QMargins(0, 0, 0, 0));
    
    qDebug() << "添加角标区域: 64x60像素，占用A1-B2网格";
    
    // 2. 动态创建菜单栏区域（第1行C1-O1，Z-Value: 0，底层）
    auto menuBarContainer = new QWidget();
    auto menuBarLayout = new QHBoxLayout(menuBarContainer);
    // 由Overlay的Fill+padding控制左侧64px偏移与行高，这里不再设置内部左边距
    menuBarLayout->setContentsMargins(0, 4, 8, 4);
    menuBarLayout->setSpacing(2);
    
    // 动态创建所有菜单按钮并连接信号
    QStringList menuItems = {"File", "Edit", "Window", "Tools", "Build", "Select", "Actor", "Help"};
    for (const QString& menuText : menuItems)
    {
        auto menuButton = new QPushButton(menuText);
        menuButton->setFlat(true);
        menuButton->setObjectName(menuText.toLower() + "MenuButton");
        
        // 为每个菜单按钮设置图标和连接信号
        if (menuText == "File")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_DirIcon));
            connect(menuButton, &QPushButton::clicked, this, &VGMainWindow::onShowFileMenu);
        }
        else if (menuText == "Edit")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_FileDialogDetailedView));
            connect(menuButton, &QPushButton::clicked, this, &VGMainWindow::onShowEditMenu);
        }
        else if (menuText == "Window")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_TitleBarNormalButton));
            connect(menuButton, &QPushButton::clicked, this, &VGMainWindow::onShowWindowMenu);
        }
        else if (menuText == "Tools")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_ComputerIcon));
        }
        else if (menuText == "Build")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay));
        }
        else if (menuText == "Select")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_ArrowRight));
        }
        else if (menuText == "Actor")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_FileIcon));
        }
        else if (menuText == "Help")
        {
            menuButton->setIcon(style()->standardIcon(QStyle::SP_DialogHelpButton));
        }
        
        menuBarLayout->addWidget(menuButton);
    }

    menuBarLayout->addStretch(); // 右侧弹性空间
    
    menuBarContainer->setObjectName("menuBarArea");
    // 使用Fill + padding: 左64px，底30px，填充第一行
    overlay->addWidget(menuBarContainer, 0, OverlayAlignment::Fill, QMargins(64, 0, 0, 30));
    
    qDebug() << "添加菜单栏区域: 第1行C1-O1，从角标右侧开始显示";
    
    // 3. 动态创建标签管理器区域（第2行，从B2开始顶格排列，Z-Value: 0，底层）
    auto tabWellContainer = new QWidget();
    tabWellContainer->setObjectName("tabWellContainer");
    auto tabLayout = new QHBoxLayout(tabWellContainer);
    // 由Overlay控制左侧64px偏移与行高，这里不再设置内部左边距
    tabLayout->setContentsMargins(0, 0, 0, 0);
    tabLayout->setSpacing(0);
    
    // 动态创建DockingTabWell
    auto mainTabWell = new DockingTabWell(tabWellContainer);
    mainTabWell->setObjectName("mainTabWell");
    // 强制设置DockingTabWell的尺寸，仅固定高度，宽度随容器填充
    mainTabWell->setFixedHeight(30);
    mainTabWell->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    tabLayout->addWidget(mainTabWell);
    
    // 将动态创建的mainTabWell保存到成员变量，以便其他地方使用
    DynamicMainTabWell = mainTabWell;
    
    // 使用Fill + padding: 左64px，顶30px，填充第二行
    overlay->addWidget(tabWellContainer, 0, OverlayAlignment::Fill, QMargins(64, 30, 0, 0));
    
    qDebug() << "添加标签管理器区域: 第2行，与角标重叠显示";
    qDebug() << "tabWellContainer 大小:" << tabWellContainer->size();
    if (DynamicMainTabWell) {
        qDebug() << "动态mainTabWell 大小:" << DynamicMainTabWell->size();
        qDebug() << "动态mainTabWell 可见性:" << DynamicMainTabWell->isVisible();
        qDebug() << "动态mainTabWell 标签数量:" << DynamicMainTabWell->tabCount();
    }
    
    // 设置整个overlay的固定高度
    overlay->setFixedHeight(60); // 2行 * 30px = 60px
    
    // 强制刷新和显示
    tabWellContainer->show();
    tabWellContainer->setVisible(true);
    tabWellContainer->raise();
    
    if (DynamicMainTabWell) {
        DynamicMainTabWell->show();
        DynamicMainTabWell->setVisible(true);
        DynamicMainTabWell->raise();
        
        // 强制触发DockingTabWell的布局更新
        DynamicMainTabWell->updateGeometry();
        DynamicMainTabWell->update();
        DynamicMainTabWell->repaint();
    }
    
    overlay->show();
    overlay->setVisible(true);
    overlay->raise();
    
    // 强制重新布局
    tabWellContainer->adjustSize();
    if (DynamicMainTabWell) {
        DynamicMainTabWell->update();
    }
    overlay->update();
    
    // 强制触发标签重绘
    if (DynamicMainTabWell) {
        for (int i = 0; i < DynamicMainTabWell->tabCount(); ++i) {
            if (auto tab = DynamicMainTabWell->tabAt(i)) {
                tab->show();
                tab->update();
                qDebug() << "强制显示标签" << i << ":" << tab->tabTitle() << "可见性:" << tab->isVisible();
            }
        }
    }
    
    qDebug() << "=== QOverlay层叠布局设置完成 ===";
    qDebug() << "- 角标: 2x2网格 (64x60)";
    qDebug() << "- 菜单栏: 第1行，从第3列开始";
    qDebug() << "- 标签管理器: 第2行，与角标重叠";
    
    // 最终调试信息
    qDebug() << "最终检查:";
    qDebug() << "- overlay 可见性:" << overlay->isVisible() << "大小:" << overlay->size();
    qDebug() << "- tabWellContainer 可见性:" << tabWellContainer->isVisible() << "大小:" << tabWellContainer->size();
    if (DynamicMainTabWell) {
        qDebug() << "- 动态mainTabWell 可见性:" << DynamicMainTabWell->isVisible() << "大小:" << DynamicMainTabWell->size();
        qDebug() << "- 动态mainTabWell 标签数量:" << DynamicMainTabWell->tabCount();
    }
}
